import os
import re
import sys
import html2text
from bs4 import BeautifulSoup, Tag
from .request import get_res

root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
sys.path.append(root_path)

def html_to_markdown(url, referer='', target_selector=None, code_tag='plaintext'):
    """
    解析普通的HTML内容转换为markdown格式
    """

    # 获取网页内容
    response = get_res(url, referer)
    html_content = response.text

    # with open('test.html', 'r', encoding='utf-8') as f:
    #     html_content = f.read()
    
    # 使用 BeautifulSoup 解析 HTML
    soup = BeautifulSoup(html_content, 'html.parser')
    target_selector_div = None
    if target_selector:
        # 根据 class 属性查找元素（例如查找 class 为 "footer" 的 div）
        target_selector_div = soup.find(target_selector['tag'], class_=target_selector['class_'])

    # 获取需要的内容
    html_content = target_selector_div.prettify() if target_selector_div else str(soup.prettify())    

    # 转换 HTML 到 Markdown
    h = html2text.HTML2Text()
    
    # 配置 html2text，确保它不会处理我们已经创建的代码块
    h.bypass_tables = False
    h.use_automatic_links = True
    h.mark_code = True  # 将 <pre> 标签转换为代码块
    h.body_width = 0  # 禁用自动换行，以保持原始格式
   
    # 转换 HTML 到 Markdown
    markdown_content = h.handle(html_content)

    # 替换 [code] 为 ```
    # 使用正则表达式匹配 [code] 和 [/code] 之间的内容
    markdown_content = re.sub(
        r'\[code\](.*?)\[/code\]',
        lambda m: f'```{code_tag}\n{dedent_code_block(m.group(1))}\n```',
        markdown_content,
        flags=re.DOTALL  # 使 . 匹配换行符
    )

    # 处理 LaTeX 格式公式
    # 1. 处理块级公式 \\[ ... \\]
    markdown_content = re.sub(r"\\\\\[(.*?)\\\\\]", r"$$\1$$", markdown_content)
    
    # 2. 处理块级公式 \[ ... \]
    markdown_content = re.sub(r"\\\[(.*?)\\\]", r"$$\1$$", markdown_content)
    
    # 3. 处理行内公式 \( ... \)
    markdown_content = re.sub(r"\\\((.*?)\\\)", r"$\1$", markdown_content)

    # 3. 处理行内公式 \( ... \)
    markdown_content = re.sub(r"\\\((.*?)\\\)", r"$\1$", markdown_content)
    
    # 4. 处理被错误转义的行内公式 \$...\$
    markdown_content = re.sub(r"\\\$(.*?)\\\$", r"$\1$", markdown_content)
    
    # 5. 处理双反斜杠的行内公式 \\( ... \\)
    markdown_content = re.sub(r"\\\\\((.*?)\\\\\)", r"$\1$", markdown_content)
    
    return markdown_content


def dedent_code_block(code_block):
    """
    去除代码块中的多余缩进，保持相对缩进
    """
    if not code_block:
        return code_block
        
    # 分割成行
    lines = code_block.splitlines()
    
    # 找到非空行的最小缩进
    min_indent = None
    for line in lines:
        # 跳过空行
        if not line.strip():
            continue
        # 计算前导空格数
        indent = len(line) - len(line.lstrip())
        if min_indent is None or indent < min_indent:
            min_indent = indent
    
    # 如果没有找到缩进（所有行都是空行），直接返回
    if min_indent is None:
        return code_block
    
    # 移除每行开头的最小缩进数量的空格
    dedented_lines = []
    for line in lines:
        if line.strip():  # 非空行
            dedented_lines.append(line[min_indent:])
        else:  # 空行
            dedented_lines.append('')
    
    # 重新组合代码块，确保开头和结尾没有多余的空行
    return '\n'.join(dedented_lines).strip()


def wx_mp_to_markdown(url, referer='https://mp.weixin.qq.com'):
    """
    解析订阅号的文章内容转换markdown
    """

    # 获取网页内容
    response = get_res(url, referer)
    response.encoding = 'utf-8'  # 设置编码，防止乱码
    html_content = response.text
    # 转换 HTML 到 Markdown
    h = html2text.HTML2Text()
    md_content = ''
    # 使用BeautifulSoup解析HTML页面
    soup = BeautifulSoup(html_content, 'html.parser')
    # 提取标题
    rich_media_title = soup.find_all('h1')
    for title in rich_media_title:
        md_content += h.handle(str(title))
    # 定位到正文部分（需要根据实际的HTML结构调整）
    content_div = soup.find('div', class_='rich_media_content')
    if content_div:
        # 提取正文部分的HTML代码
        content_html = content_div.prettify()
        # 删除一些特殊字符
        content_html = content_html.replace("None", "")
        md_content += h.handle(str(content_html))

    return md_content


def csdn_html_to_markdown(url, referer='https://blog.csdn.net/'):
    """
    解析csdn的HTML内容转换markdown
    """

    # 获取网页内容
    response = get_res(url, referer)
    html_content = response.text

    # 解析 HTML
    soup = BeautifulSoup(html_content, 'html.parser')

    md_content = ''

    # 转换 HTML 到 Markdown
    h = html2text.HTML2Text()

    # 提取 <h1> 标签内容
    headers = soup.find_all('h1')
    for header in headers:
        md_content += h.handle(str(header))

    # 提取 <article> 标签内容
    articles = soup.find_all('article')
    for article in articles:
        md_content += h.handle(str(article))
    # 格式化md表格的内容
    match_content = match_md_table_content(md_content)
    if match_content:
        format_content = format_md_table_content(match_content)
        return md_content.replace(match_content, format_content)
    else:
        return md_content


'''

匹配文本内容中表格的段落

pattern = r"(---\|---(\|---)*\s*[\r\n]+.*?[\r\n]+[\r\n])" 正则表达式含义如下：
1.---\|---：匹配开始的 "---|---" 部分。
2.(\|---)*：匹配任意数量的 |---，应对不同列数的情况。
3.\s*[\r\n]+：匹配任意数量的空白字符后跟一个或多个换行符。
4..*?：非贪婪地匹配任意字符直到下一个换行符。
5.[\r\n]+[\r\n]：匹配连续的换行符，表示末尾是空行。
使用 re.DOTALL 模式使 . 匹配包括换行符在内的任意字符。这个正则表达式会找到所有符合模式的文本段落。


pattern = r"(---\|---(\|---)*.*?)(?=\r?\n\r?\n|\r?\n[###|#|##])" 正则表达式含义如下：
1.---\|---(\|---)*.*?：这部分用于匹配以 ---|--- 开头的字符串，后面可以跟随任意数量的 |---。. 表示任意字符，* 表示前面的字符可以出现任意次数，? 表示非贪婪模式，也就是说它会尽可能少的匹配字符。
2.(?=\r?\n\r?\n|\r?\n[###|#|##])：这部分是一个前瞻断言，用于匹配后面跟随着两个换行符（\r?\n\r?\n）或者一个换行符后面跟随 ###、# 或 ## 的位置。前瞻断言只匹配位置，不消耗字符，也就是说它只检查是否存在符合条件的字符串，但并不包含在整个匹配结果中。\r?\n 可以匹配 Unix/Linux 系统的换行符 \n 或者 Windows 系统的换行符 \r\n。
所以，这个正则表达式可以匹配以 ---|--- 开头，后面跟随任意数量的 |---，然后是任意字符，直到遇到两个换行符或者一个换行符后面跟随 ###、# 或 ## 的位置。希望这个答案对您有所帮助！

'''


def match_md_table_content(text):
    #pattern = r"(---\|---(\|---)*\s*[\r\n]+.*?[\r\n]+[\r\n])"
    # matches = re.findall(pattern, text, re.DOTALL)
    # result = ''
    # for match in matches:
    #     result = match[0]
    #     break
    # return result
    pattern = r"(---\|---(\|---)*.*?)(?=\r?\n\r?\n|\r?\n[###|#|##])"
    matches = re.search(pattern, text, re.DOTALL)
    if matches:
        return matches.group()
    else:
        print("md table content No found")


def format_md_table_content(text):
    """
    格式化markdown表格内容

    pattern = r"^(.*?\|.*?)\s*?$" 正则表达式含义如下：
    1.^ 表示一行的开始。
    2.(.*?) 是一个捕获组，.*? 表示匹配任意字符（. 表示任意字符，* 表示任意数量，? 使其成为非贪婪匹配），直到遇到下一个模式。
    3.\| 表示匹配字符 |。在正则表达式中，| 是一个特殊字符，所以需要用 \ 进行转义。
    4..*? 再次表示非贪婪地匹配任意字符，直到行的末尾。
    5.\s*? 匹配任意数量的空白字符（包括空格、制表符等），*? 表示非贪婪匹配。
    6.$ 表示一行的结束。
    """

    pattern = r"^(.*?\|.*?)\s*?$"
    # 按行分割文本
    lines = text.strip().split('\n')
    # 合并行
    merged_lines = []
    for line in lines:
        if re.match(pattern, line.strip()):
            merged_lines.append(line.strip())
        elif merged_lines :
            # merged_lines[-1] 这种表达式是用来访问列表中的最后一个元素，因此，-1 就是列表中的最后一个元素，-2 是倒数第二个元素，以此类推。
            merged_lines[-1] += ' ' + line.strip()

    # 合并后的文本，再次以换行分割
    merged_text = '\n'.join(merged_lines)
    # 末尾连续两次换行分割后面的内容段落
    return merged_text + '\n\n'

